package com.ruoyi.module.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ruoyi.module.domain.DictBook;
import com.ruoyi.module.domain.DictBookTag;
import com.ruoyi.module.domain.DictTag;
import com.ruoyi.module.mapper.DictBookMapper;
import com.ruoyi.module.mapper.DictBookTagMapper;
import com.ruoyi.module.mapper.DictTagMapper;
import com.ruoyi.module.service.IDictBookService;

/**
 * 词典Service业务层处理
 * 
 * @author ruoyi
 */
@Service
public class DictBookServiceImpl implements IDictBookService
{
    @Autowired
    private DictBookMapper dictBookMapper;

    @Autowired
    private DictBookTagMapper dictBookTagMapper;

    @Autowired
    private DictTagMapper dictTagMapper;

    /**
     * 查询词典列表
     * 
     * @param dictBook 词典
     * @return 词典
     */
    @Override
    public List<DictBook> selectDictBookList(DictBook dictBook)
    {
        List<DictBook> list = dictBookMapper.selectDictBookList(dictBook);
        // 填充标签信息
        for (DictBook book : list)
        {
            List<DictTag> tagList = dictTagMapper.selectDictTagListByBookId(book.getId());
            book.setTagList(tagList);
            // 填充标签名称列表
            List<String> tags = new ArrayList<>();
            for (DictTag tag : tagList)
            {
                tags.add(tag.getName());
            }
            book.setTags(tags);
        }
        return list;
    }

    /**
     * 查询词典列表（带标签信息，支持标签筛选）
     * 
     * @param dictBook 词典
     * @return 词典
     */
    @Override
    public List<DictBook> selectDictBookListWithTags(DictBook dictBook)
    {
        List<DictBook> list = dictBookMapper.selectDictBookListWithTags(dictBook);
        // 填充标签名称列表
        for (DictBook book : list)
        {
            List<String> tags = new ArrayList<>();
            if (book.getTagList() != null)
            {
                for (DictTag tag : book.getTagList())
                {
                    if (tag != null && tag.getName() != null)
                    {
                        tags.add(tag.getName());
                    }
                }
            }
            book.setTags(tags);
        }
        return list;
    }

    /**
     * 查询用户有权限的词典列表
     * 
     * @param dictBook 词典查询条件
     * @param userId 用户ID
     * @return 词典集合
     */
    @Override
    public List<DictBook> selectDictBookListByUserId(DictBook dictBook, Long userId)
    {
        List<DictBook> list = dictBookMapper.selectDictBookListByUserId(dictBook, userId);
        // 填充标签信息
        for (DictBook book : list)
        {
            List<DictTag> tagList = dictTagMapper.selectDictTagListByBookId(book.getId());
            book.setTagList(tagList);
            // 填充标签名称列表
            List<String> tags = new ArrayList<>();
            for (DictTag tag : tagList)
            {
                tags.add(tag.getName());
            }
            book.setTags(tags);
        }
        return list;
    }

    /**
     * 根据语言分类查询词典列表
     * 
     * @param languageCategory 语言分类ID
     * @return 词典集合
     */
    @Override
    public List<DictBook> selectDictBookListByLanguageCategory(String languageCategory)
    {
        return dictBookMapper.selectDictBookListByLanguageCategory(languageCategory);
    }

    /**
     * 根据ID查询词典详情（包含标签）
     * 
     * @param id 词典ID
     * @return 词典
     */
    @Override
    public DictBook selectDictBookById(String id)
    {
        DictBook book = dictBookMapper.selectDictBookById(id);
        if (book != null)
        {
            // 查询标签
            List<DictTag> tagList = dictTagMapper.selectDictTagListByBookId(id);
            book.setTagList(tagList);
            // 填充标签名称列表
            List<String> tags = new ArrayList<>();
            for (DictTag tag : tagList)
            {
                tags.add(tag.getName());
            }
            book.setTags(tags);
        }
        return book;
    }

    /**
     * 新增词典
     * 
     * @param dictBook 词典
     * @return 结果
     */
    @Override
    @Transactional
    public int insertDictBook(DictBook dictBook)
    {
        int result = dictBookMapper.insertDictBook(dictBook);
        // 插入标签关联
        insertDictBookTags(dictBook);
        return result;
    }

    /**
     * 修改词典
     * 
     * @param dictBook 词典
     * @return 结果
     */
    @Override
    @Transactional
    public int updateDictBook(DictBook dictBook)
    {
        // 删除原有关联
        dictBookTagMapper.deleteDictBookTagByBookId(dictBook.getId());
        // 插入新的关联
        insertDictBookTags(dictBook);
        return dictBookMapper.updateDictBook(dictBook);
    }

    /**
     * 批量删除词典
     * 
     * @param ids 需要删除的词典ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteDictBookByIds(String[] ids)
    {
        // 删除词典标签关联
        dictBookTagMapper.deleteDictBookTagByBookIds(ids);
        return dictBookMapper.deleteDictBookByIds(ids);
    }

    /**
     * 删除词典信息
     * 
     * @param id 词典ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteDictBookById(String id)
    {
        // 删除词典标签关联
        dictBookTagMapper.deleteDictBookTagByBookId(id);
        return dictBookMapper.deleteDictBookById(id);
    }

    /**
     * 插入词典标签关联
     * 
     * @param dictBook 词典对象
     */
    private void insertDictBookTags(DictBook dictBook)
    {
        if (dictBook.getTags() != null && dictBook.getTags().size() > 0)
        {
            List<DictBookTag> dictBookTagList = new ArrayList<>();
            for (String tagName : dictBook.getTags())
            {
                // 查询标签是否存在
                DictTag tag = dictTagMapper.selectDictTagByName(tagName);
                if (tag == null)
                {
                    // 标签不存在，创建新标签
                    tag = new DictTag();
                    tag.setName(tagName);
                    dictTagMapper.insertDictTag(tag);
                }
                // 插入关联
                DictBookTag dictBookTag = new DictBookTag();
                dictBookTag.setBookId(dictBook.getId());
                dictBookTag.setTagId(tag.getId());
                dictBookTagList.add(dictBookTag);
            }
            if (dictBookTagList.size() > 0)
            {
                dictBookTagMapper.batchInsertDictBookTag(dictBookTagList);
            }
        }
    }
}

